.TH std::ranges::views::zip,std::ranges::zip_view 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::views::zip,std::ranges::zip_view \- std::ranges::views::zip,std::ranges::zip_view

.SH Synopsis
   Defined in header <ranges>
   template< ranges::input_range... Views >

       requires (ranges::view<Views> && ...) && (sizeof...(Views) >
   0)                                                                 \fB(1)\fP (since C++23)
   class zip_view

       : public ranges::view_interface<zip_view<Views...>>
   namespace views {

       inline constexpr /*unspecified*/ zip = /*unspecified*/;        \fB(2)\fP (since C++23)

   }
   Call signature
   template< ranges::viewable_range... Rs >

       requires /* see below */                                           (since C++23)

   constexpr auto zip( Rs&&... rs );

   1) zip_view is a range adaptor that takes one or more views, and produces a view
   whose ith element is a tuple-like value consisting of the i^th elements of all
   views. The size of produced view is the minimum of sizes of all adapted views.
   2) views::zip is a customization point object.

   When calling with no argument, views::zip() is expression-equivalent to
   auto(views::empty<std::tuple<>>).

   Otherwise, views::zip(rs...) is expression-equivalent to
   ranges::zip_view<views::all_t<decltype((rs))>...>(rs...).

   zip_view always models input_range, and models forward_range, bidirectional_range,
   random_access_range, or sized_range if all adapted view types model the
   corresponding concept.

   zip_view models common_range if

     * sizeof...(Views) is equal to 1, and the only adapted view type models
       common_range, or
     * at least one adapted view type does not model bidirectional_range, and every
       adapted view type models common_range, or
     * every adapted view type models both random_access_range and sized_range.

.SH Member functions

   constructor   constructs a zip_view
   (C++23)       \fI(public member function)\fP
   begin         returns an iterator to the beginning
   (C++23)       \fI(public member function)\fP
   end           returns an iterator or a sentinel to the end
   (C++23)       \fI(public member function)\fP
   size          returns the number of elements. Provided only if each underlying
   (C++23)       (adapted) range satisfies sized_range.
                 \fI(public member function)\fP
         Inherited from std::ranges::view_interface
   empty         returns whether the derived view is empty. Provided if it satisfies
   (C++20)       sized_range or forward_range.
                 \fI(public member function of std::ranges::view_interface<D>)\fP
   cbegin        returns a constant iterator to the beginning of the range.
   (C++23)       \fI(public member function of std::ranges::view_interface<D>)\fP
   cend          returns a sentinel for the constant iterator of the range.
   (C++23)       \fI(public member function of std::ranges::view_interface<D>)\fP
   operator bool returns whether the derived view is not empty. Provided if
   (C++20)       ranges::empty is applicable to it.
                 \fI(public member function of std::ranges::view_interface<D>)\fP
   front         returns the first element in the derived view. Provided if it
   (C++20)       satisfies forward_range.
                 \fI(public member function of std::ranges::view_interface<D>)\fP
   back          returns the last element in the derived view. Provided if it satisfies
   (C++20)       bidirectional_range and common_range.
                 \fI(public member function of std::ranges::view_interface<D>)\fP
   operator[]    returns the n^th element in the derived view. Provided if it satisfies
   (C++20)       random_access_range.
                 \fI(public member function of std::ranges::view_interface<D>)\fP

   Deduction guides

   Nested classes

   iterator the iterator type
   (C++23)  (exposition-only member class template*)
   sentinel the sentinel type used when zip_view is not a common_range
   (C++23)  (exposition-only member class template*)

   Helper templates

   template< class... Views >

   inline constexpr bool                                                  (since C++23)
   enable_borrowed_range<ranges::zip_view<Views...>> =

       (ranges::enable_borrowed_range<Views> && ...);

   This specialization of ranges::enable_borrowed_range makes zip_view satisfy
   borrowed_range when each underlying view satisfies it.

.SH Notes

    Feature-test macro   Value    Std                 Feature
                                        std::ranges::zip_view,
   __cpp_lib_ranges_zip 202110L (C++23) std::ranges::zip_transform_view,
                                        std::ranges::adjacent_view,
                                        std::ranges::adjacent_transform_view

.SH Example


// Run this code

 #include <array>
 #include <iostream>
 #include <list>
 #include <ranges>
 #include <string>
 #include <tuple>
 #include <vector>

 void print(auto const rem, auto const& range)
 {
     for (std::cout << rem; auto const& elem : range)
         std::cout << elem << ' ';
     std::cout << '\\n';
 }

 int main()
 {
     auto x = std::vector{1, 2, 3, 4};
     auto y = std::list<std::string>{"α", "β", "γ", "δ", "ε"};
     auto z = std::array{'A', 'B', 'C', 'D', 'E', 'F'};

     print("Source views:", "");
     print("x: ", x);
     print("y: ", y);
     print("z: ", z);

     print("\\nzip(x,y,z):", "");

     for (std::tuple<int&, std::string&, char&> elem : std::views::zip(x, y, z))
     {
         std::cout << std::get<0>(elem) << ' '
                   << std::get<1>(elem) << ' '
                   << std::get<2>(elem) << '\\n';

         std::get<char&>(elem) += ('a' - 'A'); // modifies the element of z
     }

     print("\\nAfter modification, z: ", z);
 }

.SH Output:

 Source views:
 x: 1 2 3 4
 y: α β γ δ ε
 z: A B C D E F

 zip(x,y,z):
 1 α A
 2 β B
 3 γ C
 4 δ D

 After modification, z: a b c d E F

.SH See also

   ranges::zip_transform_view a view consisting of tuples of results of application of
   views::zip_transform       a transformation function to corresponding elements of
   (C++23)                    the adapted views
                              \fI(class template)\fP (customization point object)
   ranges::elements_view      takes a view consisting of tuple-like values and a number
   views::elements            N and produces a view of N^th element of each tuple
   (C++20)                    \fI(class template)\fP (range adaptor object)
